import { getSystemInfoSync, platform } from "@ray-js/ray";
import { forIn } from "lodash-es";
import { useMemo } from "react";
const systemInfo = getSystemInfoSync();




export interface TimeGroup {
  startTime: number;    // 开启时间（分钟）
  endTime: number;      // 关闭时间（分钟）
  temperature: number;  // 设定温度（℃）
}

// 定义每段数据的结构类型
export interface SegmentData {
  groups: TimeGroup[];     // 4组时间数据
  selectionMark: string;   // 组选中标记（8位二进制字符串）
  weekDay: string;         // 适用星期（8位二进制字符串）
}

let __systemCacheInfo = null;
export const getSystemCacheInfo = (): { screenWidth: number; screenHeight: number } => {
  if (!__systemCacheInfo) {
    __systemCacheInfo = getSystemInfoSync();
  }
  return __systemCacheInfo;
};
/**
 * @description 将标准像素转换为适配后的像素
 * @param stdPx 标准像素
 * @param toFixed 保留小数点后几位
 * @returns 适配后的像素
 */
export const useStdPx2Adapt = (stdPx: number, toFixed = 2): number => {
  const { screenWidth } = useMemo(() => getSystemCacheInfo(), [stdPx]);
  return +(stdPx * (screenWidth / 375)).toFixed(toFixed) || stdPx;
};
/**
   * 是否在加热中:1.低档 .2.高档 3.自动时，并且处在加热时间段
   */
export function isHeating(myHeatSet: string, heatMode: string): boolean {
  if (heatMode == null || myHeatSet == null) {
    return false;
  }
  if (heatMode === 'manual_low' || heatMode === 'manual_high') {
    return true;

  }
  // 打印原始数据长度用于调试
  console.log('myHeatSet-字数长度', myHeatSet?.length);

  // 验证数据类型和长度是否符合预期的176字符长度
  if (typeof myHeatSet === 'string' && myHeatSet.length === 176) { // 修改条件判断为176字符

    // 输出有效数据提示
    console.log('myHeatSet-有效数据');

    // 定义数据结构参数
    const segmentLength = 22; // 每段22字节
    const totalSegments = 4;  // 总共4段
    const groupsPerSegment = 4; // 每段包含4组数据
    const newParsedData: SegmentData[] = [];

    // 遍历每个数据段
    for (let segmentIdx = 0; segmentIdx < totalSegments; segmentIdx++) {

      // 计算当前段在字符串中的起始位置（每个字节用2个十六进制字符表示）
      const segmentStart = segmentIdx * segmentLength * 2; //0x44 ,1x44,2x44,3x44(0,44,88,132)
      // console.log('segmentStart:' + segmentIdx, segmentStart);
      // 创建当前段的组数据数组
      const groups: TimeGroup[] = [];

      // 解析段内的每组数据
      for (let groupIdx = 0; groupIdx < groupsPerSegment; groupIdx++) {

        // 计算当前组在字符串中的起始位置
        const groupStart = segmentStart + groupIdx * 5 * 2; // 每组5字节，转为16进制字符串位置
        // console.log('groupStart:' + groupIdx, groupStart);
        // 提取并解析开启时间的十六进制字符串
        const startTimeHex = myHeatSet.slice(groupStart, groupStart + 4);
        const startTime = parseInt(startTimeHex, 16);

        // 提取并解析关闭时间
        const endTimeHex = myHeatSet.slice(groupStart + 4, groupStart + 8);
        const endTime = parseInt(endTimeHex, 16);

        const temperature = 0;
        // 将解析后的数据添加到组数组
        groups.push({
          startTime,
          endTime,
          temperature
        });
      }

      // 提取并解析组选中标记
      const selectionMarkHex = myHeatSet.slice(segmentStart + 40, segmentStart + 42);
      const selectionMark = parseInt(selectionMarkHex, 16).toString(2).padStart(8, '0');

      // 提取并解析适用星期
      const weekDayHex = myHeatSet.slice(segmentStart + 42, segmentStart + 44);
      const weekDay = parseInt(weekDayHex, 16).toString(2).padStart(8, '0');

      // 将段数据添加到结果数组
      newParsedData.push({
        groups,
        selectionMark,
        weekDay
      });
    }

    // 输出解析后的完整数据
    console.log('解析后的数据:', newParsedData);

    const today = new Date();
    const dayOfWeek = today.getDay();//比如周二:2
    const hour = today.getHours();//小时
    const minute = today.getMinutes();//分钟
    const allMInutes = hour * 60 + minute;//将时间换算成分钟单位的number
    console.log('今天是:', today.getDay() + ',' + today.getHours() + ':' + today.getMinutes())

    // 遍历并输出每段每组的详细信息
     for(let i = 0; i < newParsedData.length; i++){
      const segment = newParsedData[i];
      // 输出段索引信息
      console.log(`段 ${i + 1} 信息:`);
      // 以二进制形式输出适用星期
      console.log(`适用星期: ${segment.weekDay}`);
      if (segment.weekDay[7 - dayOfWeek] === '1') {//找到有周二的定时
        console.log('今天是适用星期');
        // 以二进制形式输出组选中标记
        console.log(`组选中标记: ${segment.selectionMark}`);
           // 遍历并输出每组详细信息
        for(let j = 0; j < segment.groups.length; j++){
          const group = segment.groups[j];
          // 将分钟转换为小时:分钟格式
          const startMinutes = group.startTime;
          const endMinutes = group.endTime;
          console.log(`组 ${j + 1} 时间: ${startMinutes} - ${endMinutes}--${allMInutes}`);
          if (allMInutes >= startMinutes && allMInutes <= endMinutes) { //假如当前时间在段内，
              console.log('当前时间段在段内');
            if (segment.selectionMark[7 - j] === '1') {//并且是打开的
              return true;
            }else{
                console.log('当前时间段在段内');
              return false;
            }
          }
        }
      } else {
        console.log('今天不是适用星期');
      }
    };

  } else {
    // 数据不符合要求时输出错误信息
    console.error('myHeatSet 不是有效的 176 字节十六进制字符串');
  }

  return false;

}

/**
 * 
 * @param value 将摄氏度换算成摄氏度
 * @returns 
 */
export function changeCToF(value: number): number {
  return Math.round(Math.min(Math.max(value * 9 / 5 + 32, 41), 104));
}

/**
 * 
 * @param value 将华氏度换算成摄氏度
 * @returns 
 */
export function changeFToC(value: number): number {
  return Math.round(Math.min(Math.max((value - 32) * 5 / 9, 5), 40));
}

/**
 * 将分钟数转换为 HH:MM 格式的字符串
 * @param minutes - 时间值（单位：分钟）
 * @returns 格式化后的时间字符串，如 "00:00"
 */
export function formatMinutesToTime(minutes: number): string {
  // 确保输入是有效的数字
  if (isNaN(minutes) || minutes < 0) {
    return "00:00";
  }

  // 计算小时和分钟
  const hours = Math.floor(minutes / 60);
  const mins = minutes % 60;

  // 格式化为两位数的字符串
  const hoursStr = hours.toString().padStart(2, '0');
  const minsStr = mins.toString().padStart(2, '0');

  return `${hoursStr}:${minsStr}`;
}


export const getStatusBarHeight = () => {
  return systemInfo.statusBarHeight;
};


export const JsonUtil = {
  parseJSON(str) {
    let rst;
    if (str && {}.toString.call(str) === '[object String]') {
      try {
        rst = JSON.parse(str);
      } catch (e) {
        try {
          // eslint-disable-next-line
          rst = eval(`(${str})`);
        } catch (e2) {
          rst = str;
        }
      }
    } else {
      rst = typeof str === 'undefined' ? {} : str;
    }

    return rst;
  },
};

export function getCircleIndex(values: number[], index: number): number {
  let length = 1000;//记这个坐标与这9个点最近的值
  let minIndex = 1;//记录最接近的点

  for (let i = 1; i <= values.length; i++) {
    const mindleValue = values[i - 1];
    const distance = Math.abs(index - mindleValue);
    console.log('getValue-1-计算与每一段中心点的距离,minIndex:' + minIndex + ',distance:' + distance);
    if (distance < length) {
      length = distance;
      minIndex = i;
      console.log('getValue-2-记录最小距离值length:' + length + ',minIndex:' + minIndex);
    }
  }
  console.log('getValue-3-最接近的点是minIndex:' + minIndex + ",index:" + index);
  return minIndex;
}

/**
 * 修改指定 byte 的指定 bit 位的值（0 或 1）
 * @param hexStr 原始的 16 进制字符串（如：'0532000007640764066407640264de'）
 * @param byteIndex 要修改的 byte 位置（从 0 开始）
 * @param bitIndex 要修改的 bit 位置（从 0 到 7，0 是最低位）
 * @param value 要设置的值（0 或 1）
 * @returns 修改后的 16 进制字符串
 */
export const setBitAt = (hexStr: string, byteIndex: number, value: 0 | 1): string => {
  // 检查参数合法性
  if (byteIndex < 0 || byteIndex >= hexStr.length / 2) {//这样最大就是不能超过15
    throw new Error('byteIndex 超出范围');
  }

  // 将 16 进制字符串转为 Uint8Array
  const bytes = new Uint8Array(hexStr.length / 2);
  for (let i = 0; i < hexStr.length; i += 2) {
    bytes[i / 2] = parseInt(hexStr.slice(i, i + 2), 16);
  }

  // 获取目标 byte
  let targetByte = bytes[byteIndex];
  console.log('setBitAt', '获取目标byte:' + targetByte);

  // 设置或清除指定 bit
  //~ 是 按位取反 运算符
  if (value === 1) {
    targetByte |= 1; // 设置最低位为 1
  } else {
    targetByte &= ~1; // 设置最低位为 0
  }
  // 替换回数组
  bytes[byteIndex] = targetByte;
  // 转换回 16 进制字符串
  let newHexStr = '';
  for (let i = 0; i < bytes.length; i++) {
    const hex = bytes[i].toString(16).padStart(2, '0');
    newHexStr += hex;
  }
  return newHexStr;
}

/**
 * 获取指定 byte 的指定 bit 位的值（0 或 1）
 * @param hexStr 原始的 16 进制字符串（如：'0532000007640764066407640264de'）
 * @param byteIndex 要查询的 byte 位置（从 0 开始）
 * @param bitIndex 要查询的 bit 位置（从 0 到 7，0 是最低位）
 * @returns 指定 bit 的值（0 或 1）
 */
export const getBitAt = (hexStr: string, byteIndex: number): number => {
  // 检查参数合法性
  if (byteIndex < 0 || byteIndex >= hexStr.length / 2) {
    throw new Error('byteIndex 超出范围');
  }

  // 将 16 进制字符串转为 Uint8Array
  const bytes = new Uint8Array(hexStr.length / 2);
  for (let i = 0; i < hexStr.length; i += 2) {
    bytes[i / 2] = parseInt(hexStr.slice(i, i + 2), 16);
  }

  // 获取目标 byte
  const targetByte = bytes[byteIndex];

  // 判断指定 bit 的值
  return targetByte & 0x01;
};


/**
 * 
 * @param hexStr 取第一个byte的7，除去最低位的剩余7位十进制数
 * @returns 
 */
export const getColorValue = (hexStr: string, byteIndex: number): number => {

  // 将 16 进制字符串转为 Uint8Array
  const bytes = new Uint8Array(hexStr.length / 2);
  for (let i = 0; i < hexStr.length; i += 2) {
    bytes[i / 2] = parseInt(hexStr.slice(i, i + 2), 16);
  }
  const byteSec = bytes[byteIndex]; //取第byteIndex个byte十进制值

  // 获取目标byte,并且去掉高位第7位的值
  const targetByte = byteSec >> 1;

  // 判断指定 bit 的值
  return targetByte;
};

/**
 * 
 * @param hexStr 获取火焰亮度滑动条的亮度值
 * @returns 
 */
export const getSliderValue = (hexStr: string, byteIndex: number): number => {


  // 将 16 进制字符串转为 Uint8Array
  const bytes = new Uint8Array(hexStr.length / 2);
  for (let i = 0; i < hexStr.length; i += 2) {
    bytes[i / 2] = parseInt(hexStr.slice(i, i + 2), 16);
  }
  const byteSec = bytes[byteIndex]; //取第byteIndex个byte十进制值
  // 获取目标byte
  const targetByte = byteSec & 0xFF;
  // 判断指定 bit 的值
  return targetByte;
};

//设置火焰的颜色值：1-9
export function setColorByteInHex(hexStr: string, byteIndex: number, colorValue: number): string {
  // 检查 colorValue 的合法性

  // 将 hexStr 转换为 Uint8Array
  const bytes = new Uint8Array(hexStr.length / 2);
  for (let i = 0; i < hexStr.length; i += 2) {
    bytes[i / 2] = parseInt(hexStr.slice(i, i + 2), 16);
  }

  // 修改第一个 byte：设置最低位为 1，将 colorValue 写入 bit 1 ~ bit 7

  let modifiedByte = 0x00; // 清空所有位
  modifiedByte |= (colorValue << 1); // 将 colorValue 写入 bit 1 ~ bit 7
  modifiedByte |= 1; // 设置最低位（bit 0）为 1，表示有效

  bytes[byteIndex] = modifiedByte; // 替换回数组

  // 将字节数组转换回十六进制字符串
  let newHexStr = '';
  for (let i = 0; i < bytes.length; i++) {
    const hex = bytes[i].toString(16).padStart(2, '0');
    newHexStr += hex;
  }
  return newHexStr;
}

export function setSliderInHex(hexStr: string, byteIndex: number, sliderValue: number): string {
  // 检查 colorValue 的合法性
  if (sliderValue < 0 || sliderValue > 100) {
    throw new Error('颜色值必须在 1 到 9 之间');
  }

  // 将 hexStr 转换为 Uint8Array
  const bytes = new Uint8Array(hexStr.length / 2);
  for (let i = 0; i < hexStr.length; i += 2) {
    bytes[i / 2] = parseInt(hexStr.slice(i, i + 2), 16);
  }

  // 修改第一个 byte：设置最高位为 1，并将颜色值写入低 7 位
  let modifiedByte = 0x00; // 清除8位
  modifiedByte |= sliderValue; // 将颜色值写入整个8位

  bytes[byteIndex] = modifiedByte; // 替换回数组

  // 将字节数组转换回十六进制字符串
  let newHexStr = '';
  for (let i = 0; i < bytes.length; i++) {
    const hex = bytes[i].toString(16).padStart(2, '0');
    newHexStr += hex;
  }
  return newHexStr;
}



export const rpx2pxNum = (maybeRpx: string | number) => {
  if (typeof maybeRpx === 'string') {
    console.log('rpx2pxNum', '1');
    if (maybeRpx.endsWith('rpx')) {
      console.log('rpx2pxNum', '1-1');
      const value = Number(maybeRpx.replace(/rpx/g, ''));
      if (platform.isMiniProgram) {
        return (value / 750) * systemInfo.windowWidth;
      }
      if (platform.isWeb) {
        return value / 2;
      }
    } else if (maybeRpx.endsWith('px')) {
      console.log('rpx2pxNum', '1-2');
      const value = Number(maybeRpx.replace(/px/g, ''));
      return Number(value);
    }
  } else {
    console.log('rpx2pxNum', '2');
    if (platform.isMiniProgram) {
      return (maybeRpx / 750) * systemInfo.windowWidth;
    }
    if (platform.isWeb) {
      return maybeRpx / 2;
    }
  }
  return Number(maybeRpx);
};

export const px2rpxNum = (maybeRpx: string | number) => {
  if (typeof maybeRpx === 'string') {
    if (maybeRpx.endsWith('rpx')) {
      const value = Number(maybeRpx.replace(/rpx/g, ''));
      return value;
    }
    if (maybeRpx.endsWith('px')) {
      const value = Number(maybeRpx.replace(/px/g, ''));
      if (platform.isMiniProgram) {
        return (value * 750) / systemInfo.windowWidth;
      }
      if (platform.isWeb) {
        return value * 2;
      }
    }
  }
  if (platform.isMiniProgram) {
    return (Number(maybeRpx) * 750) / systemInfo.windowWidth;
  }
  if (platform.isWeb) {
    return Number(maybeRpx) * 2;
  }
  return Number(maybeRpx);
};

export const promisify = (func: Function) => {
  return function (...args): Promise<any> {
    return new Promise((resolve, reject) => {
      func(Object.assign({}, ...args, { success: resolve, fail: reject }));
    })
  }
}

export const sleep = (time: number) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(time);
    }, time);
  });
}

export function c2fScale(c: number) {
  return Math.round(c * 1.8 * 100) / 100;
}

export function f2cScale(f: number) {
  return Math.round(f / 1.8 * 100) / 100;
}

export const reverseScaleNumber = (scale: number, value: number) => {
  while (scale > 0) {
    value *= 10;
    scale--;
  }
  return Number(value);
}

export const setGlobalStyleVariables = (uniqueKey: string | string[], value: number | number[], decimal: boolean) => {

  function getStyleFromValue(uniqueKey, singleValue: number) {
    if (isNaN(singleValue)) return console.error('value must be a number');

    // 获取value的整数位 和 小数位 最多两位
    const [intValue, decimalValue = "0"] = (Math.round(singleValue * 100) / 100).toString().split('.');
    const style = {};
    if (decimal) {
      style[`--${uniqueKey}-int`] = intValue;
      style[`--${uniqueKey}-decimal`] = decimalValue || "0";
    } else {
      style[`--${uniqueKey}`] = intValue;
    }
    return style;
  }

  if (Array.isArray(value)) {
    const [start, end] = value;
    if (uniqueKey.length > 1) {
      const style = {
        ...getStyleFromValue(`${uniqueKey[0]}`, start),
        ...getStyleFromValue(`${uniqueKey[1]}`, end),
      };
      // @ts-ignore
      ty.setPageStyle({ style: style })
    } else {
      throw new Error("uniqueKey must be an array when value is an array");
    }
  } else {
    const style = getStyleFromValue(uniqueKey, value);
    // @ts-ignore
    ty.setPageStyle({ style: style })
    return uniqueKey;
  }
}